package com.zkyc.framework.website.controller;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.zkyc.framework.common.annotation.Log;
import com.zkyc.framework.common.annotation.Timing;
import com.zkyc.framework.common.exception.ResultCode;
import com.zkyc.framework.common.pojo.Column;
import com.zkyc.framework.common.pojo.ColumnData;
import com.zkyc.framework.common.vo.ResultVO;
import com.zkyc.framework.common.vo.website.ColumnDataPageVo;
import com.zkyc.framework.common.vo.website.ColumnDataRefVo;
import com.zkyc.framework.common.vo.website.ColumnSaveVo;
import com.zkyc.framework.common.vo.website.ModuleColumnGeneratorVo;
import com.zkyc.framework.website.service.ColumnService;
import org.springframework.web.bind.annotation.*;
import com.zkyc.framework.common.Enum.LogType;

import javax.annotation.Resource;
import java.util.List;

/**
 * (Column)表控制层
 *
 * @author libingchuan
 * @since 2022-05-25 15:04:30
 */
@RestController
@RequestMapping("column")
public class ColumnController {
    /**
     * 服务对象
     */
    @Resource(name = "columnService")
    private ColumnService columnService;
    
    /**
     * 查询
     *
     * @return 查询结果
     */
    @GetMapping("list")
    public ResultVO queryList(Integer columnType) {
        return columnService.queryList(columnType);
    }

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("/query/{id}")
    public ResultVO queryById(@PathVariable("id") Integer id) {
        Column column = columnService.queryById(id);
        if(column == null){
            return ResultVO.fail(ResultCode.SERVE_ERROR);
        }
        return ResultVO.data(column);
    }


    /**
     * 通过主键查询单条数据
     *
     * @param moudleId 主键
     * @return 单条数据
     */
    @GetMapping("/queryByMoudleId")
    public ResultVO queryByMoudleId(Integer moudleId) {
        List<Column> column = columnService.queryByMoudleId(moudleId);
        if(column == null){
            return ResultVO.fail(ResultCode.SERVE_ERROR);
        }
        return ResultVO.data(column);
    }

    /**
     * 新增数据
     *
     * @param column 实体
     * @return 新增结果
     */
    @PostMapping("save")
    @Log(type = LogType.发布栏目)
    public ResultVO add(@RequestBody Column column) {
        return columnService.insert(column);
    }

    /**
     * 编辑数据
     *
     * @param column 实体
     * @return 编辑结果
     */
    @PostMapping("edit")
    @Log(type = LogType.发布栏目)
    public ResultVO edit(@RequestBody Column column) {
        return columnService.update(column);
    }

    /**
     * 编辑数据
     *
     * @param column 实体
     * @return 编辑结果
     */
    @PostMapping("editName")
    @Log(type = LogType.修改栏目)
    public ResultVO editName(@RequestBody Column column) {
        return columnService.updateName(column);
    }

    /**
     * 隐藏数据
     *
     * @param id 主键
     * @return 删除是否成功
     */
    @GetMapping("hide")
    public ResultVO deleteById(Integer id) {
        return columnService.hideById(id);
    }

    /**
     * 组件下拉框
     *
     * @return 组件列表
     */
    @GetMapping("components")
    public ResultVO<?> getComponents() {
        return columnService.getComponents();
    }

    /**
     * 新增数据
     *
     * @param columnSaveVo 实体
     * @return 新增结果
     */
    @PostMapping("neo/save")
    @Log(type = LogType.发布栏目)
    public ResultVO<?> save(@RequestBody ColumnSaveVo columnSaveVo) {
        return columnService.add(columnSaveVo);
    }

    /**
     * 通过moudleId查询对应栏目
     *
     * @param moudleId 路由id
     * @return 栏目数据
     */
    @GetMapping("neo/queryByMoudleId")
    public ResultVO<?> queryColumnByMoudleId(Integer moudleId) {
        return columnService.queryColumnByMoudleId(moudleId);
    }

    /**
     * 查询首页栏目
     *
     * @param moudleId 路由id
     * @return 栏目数据
     */
    @GetMapping("queryBannerByMoudleId")
    @Timing
    @HystrixCommand(fallbackMethod = "queryBannerByMoudleIdFallback")
    public ResultVO<?> queryBannerByMoudleId(Integer moudleId) {
        return columnService.queryBannerByMoudleId(moudleId);
    }
    public ResultVO<?> queryBannerByMoudleIdFallback(Integer moudleId) {
        return ResultVO.success("访问超时,请稍后再试");
    }

    /**
     * 通过moudleId查询对应栏目的数据
     *
     * @param moudleId 路由id
     * @return 栏目数据
     */
    @GetMapping("queryDataByMoudleId")
    public ResultVO<?> queryDataByMoudleId(Integer moudleId) {
        return columnService.queryDataByMoudleId(moudleId);
    }

    /**
     * 通过columnId查询对应栏目的数据
     *
     * @param columnId 路由id
     * @return 栏目数据
     */
    @GetMapping("queryDataByColumnId")
    public ResultVO<?> queryDataByColumnId(Integer columnId) {
        return columnService.queryDataByColumnId(columnId);
    }

    /**
     * 通过columnId查询对应栏目的数据
     *
     * @param columnDataPageVo 路由id
     * @return 栏目数据
     */
    @PostMapping("queryDataByColumnId")
    @Timing
    @HystrixCommand(fallbackMethod = "queryDataByColumnIdPageFallback")
    public ResultVO<?> queryDataByColumnIdPage(@RequestBody ColumnDataPageVo columnDataPageVo) {
        return columnService.queryDataByColumnIdPage(columnDataPageVo);
    }
    public ResultVO<?> queryDataByColumnIdPageFallback(@RequestBody ColumnDataPageVo columnDataPageVo) {
        return ResultVO.success("访问超时,请稍后再试");
    }

    /**
     * 添加栏目数据
     *
     * @param columnData 栏目数据
     * @return 新增结果
     */
    @Log(type = LogType.栏目数据发布)
    @PostMapping("saveData")
    public ResultVO saveData(@RequestBody ColumnData columnData) {
        return columnService.addData(columnData);
    }

    /**
     * 推荐栏目数据
     *
     * @param columnDataRefVo 栏目数据
     * @return 新增结果
     */
    @PostMapping("refData")
    @Log(type = LogType.推荐栏目数据)
    public ResultVO refData(@RequestBody ColumnDataRefVo columnDataRefVo) {
        return columnService.refData(columnDataRefVo);
    }

    /**
     * 移除推荐
     *
     * @param columnData 栏目数据
     * @return 新增结果
     */
    @PostMapping("removeRef")
    @Log(type = LogType.移除栏目数据)
    public ResultVO removeRef(@RequestBody ColumnData columnData) {
        return columnService.removeRef(columnData);
    }

    /**
     * 置顶首页栏目数据
     *
     * @param columnDataPageVo 栏目数据
     * @return 新增结果
     */
    @PostMapping("top")
    public ResultVO top(@RequestBody ColumnDataPageVo columnDataPageVo) {
        return columnService.top(columnDataPageVo);
    }

    /**
     * 查询栏目数据
     *
     * @param columnDataPageVo 查询条件
     * @return 查询结果
     */
    @PostMapping("queryData")
    public ResultVO neoQuery(@RequestBody ColumnDataPageVo columnDataPageVo) {
        return columnService.neoQuery(columnDataPageVo);
    }

    /**
     * 编辑数据
     *
     * @param columnData 实体
     * @return 编辑结果
     */
    @PostMapping("editData")
    @Log(type = LogType.栏目数据编辑)
    public ResultVO editData(@RequestBody ColumnData columnData) {
        return columnService.updateData(columnData);
    }

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("/queryData/{id}")
    @HystrixCommand(fallbackMethod = "queryDataByIdFallback")
    public ResultVO queryDataById(@PathVariable("id") Integer id) {
        return columnService.queryDataById(id);
    }
    public ResultVO queryDataByIdFallback(@PathVariable("id") Integer id) {
        return ResultVO.success("访问超时,请稍后再试");
    }

    /**
     * 编辑栏目
     *
     * @param columnSaveVo 实体
     * @return 编辑结果
     */
    @PostMapping("editColumn")
    @Log(type = LogType.修改栏目)
    public ResultVO editColumn(@RequestBody ColumnSaveVo columnSaveVo) {
        return columnService.updateColumn(columnSaveVo);
    }

    /**
     * 上线下线、上移下移数据
     *
     * @param columnData 实体
     * @return 编辑结果
     */
    @PostMapping("upOrDown")
    // @Log(type = LogType.修改栏目)
    public ResultVO upOrDown(@RequestBody ColumnData columnData) {
        return columnService.upOrDown(columnData);
    }

    /**
     * 隐藏栏目数据
     *
     * @param id 主键
     * @return 删除是否成功
     */
    @GetMapping("hideData")
    @Log(type = LogType.栏目数据删除)
    public ResultVO deleteDataById(Integer id) {
        return columnService.hideDataById(id);
    }

    /**
     * 搜索
     * 匹配不到内容会将搜索内容分词后根据分词结果搜索
     *
     * @param content 搜索内容
     */
    @GetMapping("search")
    public ResultVO search(String content,
                           @RequestParam(value = "timeRange", required = false, defaultValue = "0") Integer timeRange,
                           @RequestParam(value = "searchRange", required = false, defaultValue = "0") Integer searchRange,
                           String websiteId,
                           @RequestParam(value = "current", required = false, defaultValue = "1") Integer current,
                           @RequestParam(value = "size", required = false, defaultValue = "10") Integer size
    ) {
        return columnService.search(websiteId, content, current, size, timeRange, searchRange);}

    /**
     * 生成网站时生成模块和栏目
     *
     * @param generatorVo 模板与网站信息
     */
    @PostMapping("generate")
    public ResultVO generate(@RequestBody ModuleColumnGeneratorVo generatorVo) {
        return columnService.generate(generatorVo);
    }

    /**
     * 生成网站时生成模块和栏目
     *
     * @param generatorVo 模板与网站信息
     */
    @PostMapping("generateTemp")
    public ResultVO reserveGenerate(@RequestBody ModuleColumnGeneratorVo generatorVo) {
        return columnService.reserveTemp(generatorVo);
    }

    /**
     * 删除生成的模块和栏目
     *
     * @param generatorVo 网站信息
     */
    @PostMapping("delWeb")
    public ResultVO delWeb(@RequestBody ModuleColumnGeneratorVo generatorVo) {
        return columnService.delWeb(generatorVo);
    }

    @PostMapping("temp")
    public ResultVO temp(@RequestBody ModuleColumnGeneratorVo generatorVo) {
        return columnService.temp(generatorVo);
    }

    /**
     * 稿件翻页
     * @param id 稿件id
     * @return 上一条与下一条稿件
     */
    @GetMapping("previousNext")
    public ResultVO previousNext(Integer id) {
        return columnService.previousNext(id);
    }
}

